package org.scboy.rbac.controller;

import org.scboy.common.annotation.Menu;
import org.scboy.common.annotation.Permission;
import org.scboy.common.request.Result;
import org.scboy.rbac.service.OrgTypeJoinService;
import org.scboy.rbac.service.OrgTypeService;
import org.scboy.rbac.service.ResourceOrgTypeService;
import org.scboy.utils.entitys.coobi.Model;
import org.scboy.utils.entitys.coobi.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("rbac/orgtype")
@Menu("权限管理系统.组织类型管理")
public class OrgTypeController {

	@Autowired
	OrgTypeService orgTypeService;

	@Autowired
	OrgTypeJoinService orgTypeJoinService;


	@Autowired
	ResourceOrgTypeService resourceOrgTypeService;
	
	/**
	 * 分页查询组织类型列表
	 * 
	 * @param request
	 * @return
	 */
	@PostMapping("page")
	@Permission("分页查询组织类型列表")
	public Result page(@RequestBody Model params) {
		Page page = orgTypeService.page(params);
		return Result.Success(page.getData(), page.getCount());
	}

	/**
	 * 新增组织类型
	 * 
	 * @param request
	 * @return
	 */
	@PostMapping("add")
	@Permission("新增组织类型")
	public Result add(@RequestBody Model params) {
		if (orgTypeService.add(params)) {
			return Result.Success("RBAC_ORGTYPE_ADD_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_ADD_ERROR");
		}
	}

	/**
	 * 更新组织类型
	 * 
	 * @param request
	 * @return
	 */
	@PutMapping("update")
	@Permission("更新组织类型")
	public Result update(@RequestBody Model params) {
		if (orgTypeService.update(params)) {
			return Result.Success("RBAC_ORGTYPE_UPDATE_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_UPDATE_ERROR");
		}
	}

	/**
	 * 删除组织类型
	 * 
	 * @param request
	 * @param id
	 * @return
	 */
	@DeleteMapping("delete")
	@Permission("删除组织类型")
	public Result delete(String id) {
		if (orgTypeService.delete(id)) {
			return Result.Success("RBAC_ORGTYPE_DELETE_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_DELETE_ERROR");
		}
	}

	/**
	 * 启用禁用组织类型
	 * 
	 * @param request
	 * @param id
	 * @return
	 */
	@PutMapping("checkstate")
	@Permission("启用禁用组织类型")
	public Result checkState(String id) {
		if (orgTypeService.checkState(id)) {
			return Result.Success("RBAC_ORGTYPE_CHECKSTATE_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_CHECKSTATE_ERROR");
		}
	}
	
	/**
	 * 获取启用组织类型
	 * 
	 * @param request
	 * @return
	 */
	@PostMapping("listAll")
	@Permission("获取启用组织类型")
	public Result list(@RequestBody Model params) {
		return Result.Success(orgTypeService.listAll(params), "");
	}
	/**
	 * 获取组织类型信息
	 * 
	 * @param request
	 * @param id
	 * @return
	 */
	@GetMapping("get")
	@Permission("获取组织类型信息")
	public Result get(String id) {
		return Result.Success(orgTypeService.get(id), "");
	}

	/**
	 * 设置顶级组织类型
	 * 
	 * @param request
	 * @param id
	 * @return
	 */
	@PutMapping("top")
	@Permission("设置顶级组织类型")
	public Result top(String id) {
		if (orgTypeService.top(id)) {
			return Result.Success("RBAC_ORGTYPE_TOP_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_TOP_ERROR");
		}
	}

	/**
	 * 二级组织类型分页查询
	 * 
	 * @param request
	 * @param id
	 * @return
	 */
	@PostMapping("orgjoinpage")
	@Permission("二级组织类型分页查询")
	public Result orgJoinPage(@RequestBody Model params) {
		Page page = orgTypeJoinService.page(params);
		return Result.Success(page.getData(), page.getCount());
	}

	/**
	 * 新增二级组织类型
	 * 
	 * @param request
	 * @param parentId
	 * @param subtypeId
	 * @return
	 */
	@PutMapping("addorgjoin")
	@Permission("新增二级组织类型")
	public Result addOrgJoin(String parentId,String subtypeId){
		if(orgTypeJoinService.add(parentId, subtypeId)){
			return Result.Success("RBAC_ORGTYPE_JOIN_ADD_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_JOIN_CHECK");
		}
	}

	/**
	 * 移除二级组织类型。
	 * 
	 * @param request
	 * @param id
	 * @return
	 */
	@DeleteMapping("removeorgjoin")
	@Permission("移除二级组织类型")
	public Result removeOrgJoin(String id) {
		if (orgTypeJoinService.delete(id)) {
			return Result.Success("RBAC_ORGTYPE_JOIN_REMOVE_SUCCESS");
		} else {
			return Result.Error("RBAC_ORGTYPE_JOIN_REMOVE_ERROR");
		}
	}

	/**
	 * 根据条件查询组织类型
	 * 
	 * @param request
	 * @param parentId
	 * @return
	 */
	@GetMapping("list")
	@Permission("根据条件查询组织类型")
	public Result list(String parentid) {
		return Result.Success(orgTypeService.list(parentid), "");
	}
	
	/**
	 * 升序降序
	 * @param request
	 * @param id
	 * @return
	 */
	@PutMapping("sort")
	@Permission("升序降序")
	public Result sort(String id,int type){
		if(orgTypeService.sort(id, type)){
			return Result.Success("RBAC_ORGTYPE_SORT_SUCCESS");
		}else{
			return Result.Error("RBAC_ORGTYPE_SORT_ERROR");
		}
	}
	
	

	/**
	 * 分页查询组织类型和角色关系列表
	 * @param request
	 * @return
	 */
	@PostMapping("rutpage")
	@Permission("分页查询组织类型和资源关系列表")
	public Result resourceUserTypePage(@RequestBody Model params) {
		Page page = resourceOrgTypeService.page(params);
		return Result.Success(page.getData(), page.getCount());
	}
	
	/**
	 * 新增组织类型和角色关系
	 * @param request
	 * @param orgTypeId
	 * @param roleId
	 * @return
	 */
	@PostMapping("addrut")
	@Permission("新增组织类型和资源关系")
	public Result addResourceUserType(String orgTypeId,String[] resId) {
		if (resourceOrgTypeService.addResource(orgTypeId, resId)) {
			return Result.Success("RBAC_ROLE_ORGTYPE_ADD_SUCCESS");
		} else {
			return Result.Error("RBAC_ROLE_ORGTYPE_ADD_ERROR");
		}
	}

	/**
	 * 删除组织类型和角色关系
	 * @param request
	 * @param id
	 * @return
	 */
	@DeleteMapping("deleterut")
	@Permission("删除组织类型和资源关系")
	public Result deleteResourceUserType(String id) {
		if (resourceOrgTypeService.delete(id)) {
			return Result.Success("RBAC_ROLE_ORGTYPE_DELETE_SUCCESS");
		} else {
			return Result.Error("RBAC_ROLE_ORGTYPE_DELETE_ERROR");
		}
	}
	
	/**
	 * 删除组织类型和角色关系
	 * @param request
	 * @param id
	 * @return
	 */
	@GetMapping("getrut")
	@Permission("获取组织类型相关资源ID")
	public Result getResourceUserType(String orgTypeId) {
		Model model=Model.create().add("roleId", resourceOrgTypeService.getResIds(orgTypeId)).add("orgTypeId", orgTypeId);
		return Result.Success(model,"");
	}
}
